home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: New Zealand Amiga Users Group / New Zealand Amiga Users Group Newsdisk v27 (1989-12)(NZAmigaUG).zip / New Zealand Amiga Users Group Newsdisk v27 (1989-12)(NZAmigaUG).adf / Cal / cal.asm < prev    next >
Assembly Source File  |  1993-12-03  |  39KB  |  1,335 lines
  1.  
  2.  
  3. ;    Version 1.0
  4.  
  5. ;    Cal.asm
  6. ;
  7. ;    by Steve Martin
  8. ;
  9. ;    Hope you understand this mess.
  10. ;
  11. ;  Copyright:    People can do what they want with this progrm except
  12. ;        to sell it, also I am not responsible for anything.
  13. ; 
  14.     nolist
  15.     incdir  'vd0:include/'
  16.     include    'exec/exec_lib.i'
  17.     ;include 'exec/types.i'
  18.     ;include 'exec/memory.i'
  19.     ;include 'intuition/intuition.i'
  20.     include    "libraries/dos_lib.i"
  21.  
  22.     xref    _LVOOpenLibrary
  23.     xref    _LVOCloseLibrary
  24.     xref    _LVOInput
  25.     xref    _LVOOutput
  26.     xref    _LVORead
  27.     xref    _LVOWrite
  28.  
  29.     
  30. ;    list
  31.  
  32. ExecBase equ    4
  33.  
  34. calexec MACRO
  35.     move.l    ExecBase,a6
  36.     jsr    _LVO\1(a6)
  37.     ENDM
  38.  
  39. caldos    MACRO
  40.     move.l    DosBase,a6
  41.     jsr    _LVO\1(a6)
  42.     ENDM
  43.  
  44.  
  45. ;    A0 holds the address of the command parameters
  46. ;    D0 holds the length of the command parameters    
  47. ;    command string ends with $0A
  48.  
  49.  
  50.  
  51. start    move.l    a0,ipadd    store address of command line
  52.     move.w    d0,iplen    store length of command line
  53.  
  54. getDOS    lea.l    DosName,a1    library to open
  55.     moveq    #0,d0        library version (do not care)
  56.     calexec    OpenLibrary    open library
  57.     tst.l    d0        test if succesful (0 = NG)
  58.     bne.s    DosOK
  59.     moveq    #20,d0        return code to tell user system problem
  60.     rts            return to operating system
  61.  
  62. DosOK    move.l    d0,DosBase    Save DOS base pointer
  63.     caldos    Input        find standard input
  64.     move.l    D0,stdin    save
  65.     caldos    Output        find standard output
  66.     move.l    D0,stdout    save
  67.  
  68. ;*************************************************************************
  69.  
  70. iptype    bsr    getchar        get first character form input
  71.  
  72.     cmpi.b    #"$",d1        is the number enter in HEX
  73.     bne.s    ipt2
  74.     moveq    #0,d1
  75.     bra    Selip
  76. ipt2    cmpi.b    #"@",d1        is the number enter in OCT
  77.     bne.s    ipt3
  78.     moveq    #1,d1
  79.     bra    Selip
  80. ipt3    cmpi.b    #"%",d1        is the number enter in binary
  81.     bne    ipt4
  82.     moveq    #2,d1
  83.     bra    Selip
  84. ipt4    cmpi.b    #"-",d1        is the number negative    
  85.     bne    others    
  86.     seq    neg        set neg flag
  87.     moveq    #3,d1
  88.     bra    Selip
  89.  
  90. others    subi.b    #$30,d1        is input < 0
  91.     bmi    error1        yes, error
  92.     cmpi.b    #9,d1        is the character a decimal number
  93.     bgt    error1
  94.     
  95.     sub.l    #1,ipadd    move pointer back a character
  96.     add.w    #1,iplen    incrememt length not read
  97.  
  98.     moveq    #3,d1        d1 = decimal input
  99.     
  100.  
  101. Selip    lsl    #2,d1        cal index for jump table
  102.     lea    Selipt,a0    get address of jump table
  103.     move.l    0(a0,d1.w),a0    get address of input routine
  104.     jsr    (a0)
  105.     bcs    error1
  106.     bsr    opert        if operator, action it
  107.     bmi    result
  108.     bcc.s    nip        get net input type        
  109.     bra    operr        if operator err
  110. nip    bra    iptype        check input type
  111.  
  112. Selipt    dc.l    HEXip,OCTip,BINip,DECip
  113.  
  114. ;*************************************************************************
  115.  
  116. result    clr    d0
  117.     move.b    func,d0        get function pointer
  118.     subq    #1,d0
  119.     lsl    #2,d0        cal index for jump table
  120.     lea    selfunc,a0    get address of jump table
  121.     move.l    0(a0,d0.w),a0    get address of func routine
  122.     jsr    (a0)
  123.     tst.b    err
  124.     bne    error1
  125.     bsr    HtoA
  126.     bsr    OtoA    
  127.     bsr    BtoA    
  128.     bsr    DtoA
  129.     lea    BuffHS,a3
  130.     bsr    nextlin
  131.     lea    BuffOS,a3
  132.     bsr    nextlin
  133.     lea    BuffBS,a3
  134.     bsr    nextlin
  135.     lea    BuffDS,a3
  136.     bsr    nextlin
  137.     lea    blank,a3
  138.     bsr    nextlin
  139.     bra    quit
  140.  
  141. selfunc    dc.l    add,sub,mult,div
  142.  
  143. ;*************************************************************************
  144.  
  145. quit    move.l    DosBase,a1    Close DOS library
  146.     calexec    CloseLibrary
  147.     moveq    #0,d0        Zero return code
  148.     rts            return to Operating System
  149.  
  150. ;*************************************************************************
  151.  
  152. opert    move.b    func,d2
  153.     bne.s    opequal        if func <> 0 then equal is expected
  154. add?    cmpi.b    #"+",d1        is operator +,if so func = 1
  155.     bne.s    sub?
  156.     move.b    #1,func
  157.     bra    nextval
  158. sub?    cmpi.b    #"-",d1        is operator -,if so func = 2
  159.     bne.s    mult?
  160.     move.b    #2,func
  161.     bra    nextval
  162. mult?    cmpi.b    #"*",d1        is operator *,if so func = 3
  163.     bne.s    div?
  164.     move.b    #3,func
  165.     bra    nextval
  166. div?    cmpi.b    #"/",d1        is operator /,if so func = 4
  167.     bne.s    operr1
  168.     move.b    #4,func
  169.  
  170. nextval    move.l    #4,VarPtr    Point to next variable
  171.  
  172.     rts
  173.  
  174. operr1    ori    #%1,ccr        set carry if error only
  175.     andi    #%1,ccr
  176.     rts
  177.     
  178. opequal    cmpi.b    #"=",d1        is operator =, if so get result
  179.     beq    opeq
  180.     cmpi.b    #$0a,d1        is operator a return, if so get result
  181.     beq    opeq
  182.     bra    operr1        if not, error
  183.  
  184. opeq    moveq    #-1,d1
  185.  
  186.     rts
  187.  
  188. ;*************************************************************************
  189.  
  190. operr    lea    oInfo,a3    get start address of operator error info
  191.     bsr     nextlin        output message
  192.  
  193. ;*************************************************************************
  194.  
  195. error1    lea    Info,a3        get start address of information
  196.     bsr    nextlin        output message
  197.     bra    quit
  198.  
  199. ;*************************************************************************
  200.  
  201. nextlin    move.l    a3,d2        move start address to buffer (d2) of write
  202.     moveq    #0,d3        clear length input (d3) of write
  203.  
  204. mesloop    move.b    (a3)+,d1
  205.     beq.s    wrend        if null (0) all info has been output so end
  206.     addq    #1,d3        add 1 to length
  207.     cmpi.b    #$0a,d1        check to see if at end of line
  208.     bne.s    mesloop        if not get next character
  209.     
  210.  
  211. wrinfo    move.l    stdout,d1    stdout file handle
  212.     caldos    Write        Output line to standard output (screen)
  213.     bra.s    nextlin        Output next line of info
  214.  
  215. wrend    rts
  216.  
  217. ;*************************************************************************
  218.  
  219. getchar    move.l    ipadd,a0    get address of command line
  220.     move.w    iplen,d0    get length of command line
  221.  
  222. next_c    moveq    #0,d1        clear d1
  223.     move.b    (a0)+,d1    move next character to d1 and 
  224.                 ;increment address pointer
  225.     subq    #1,d0        decrement length counter    
  226.     cmpi.b    #$20,d1        is it a space
  227.     beq.s    next_c        get next character
  228.  
  229.     move.l    a0,ipadd    save current pionter to input address
  230.     move.w    d0,iplen    save length not read
  231.  
  232.     rts
  233.  
  234. ;*************************************************************************
  235.  
  236. oper    cmpi.b    #"+",d1        is the character an operator
  237.     beq.s    op1
  238.     cmpi.b    #"-",d1
  239.     beq.s    op1
  240.     cmpi.b    #"/",d1
  241.     beq.s    op1
  242.     cmpi.b    #"*",d1
  243.     beq.s    op1
  244.     cmpi.b    #"=",d1
  245.     beq.s    op1
  246.     cmpi.b    #$0a,d1
  247.     beq.s    op1
  248.     bra.s    opend
  249. op1    ori    #1,ccr        set carry bit if an operator
  250. opend    rts
  251.  
  252. ;******************************************************************
  253. ;*                                                                *
  254. ;*                   Input handling Routines                     *
  255. ;*                                                                *
  256. ;******************************************************************
  257.  
  258. ;******************************************************************
  259. ;*                                                                *
  260. ;*                  HEX Input handling Routine                    *
  261. ;*                                                                *
  262. ;******************************************************************
  263.  
  264. HEXip    bsr    getchar
  265.     bsr    oper        is the character an operator
  266.     bcc.s    Hno_op        if carry clear, character not an operator
  267.     andi    #0,ccr        clear carry before returning
  268.     rts
  269.  
  270. Hno_op    cmpi.b    #"0",d1        if input character is less than an ascii 0
  271.     blt    Herror        then in put is in error
  272.     cmpi.b    #$3a,d1        is in put character between ,including 0 - 9
  273.     blt.s    HEXnum        yes, do not subtract $37 from ascii value 
  274.  
  275. letter    cmpi.b    #"a",d1        is input greater than a
  276.     blt.s    letter2        is character a capital letter?
  277.     andi.b    #%11011111,d1    no, so convert to a capital
  278.  
  279. letter2    cmpi.b    #"A",d1        is input between and including A and F
  280.     blt    Herror
  281.     cmpi.b    #"F",d1
  282.     bgt    Herror        no, HEX number in error
  283.     subi.b    #$7,d1        yes, convert to a value between and including
  284.                 ; 3A and 3F
  285.  
  286. HEXnum    subi.b    #$30,d1        convert input to a value between 0 and F
  287.     lea    VarPtr,a0
  288.     move.l    0(a0),d0    move VarPtr to d0
  289.     move.l    4(a0,d0.w),d2    get current variable
  290.     moveq    #0,d3        clear counter register
  291. hshift    asl.l    #1,d2        shift left 4 bit places
  292.     bcs.s    Herror        if carry set number intered was to large
  293.     addq    #1,d3        inc counter
  294.     cmpi    #4,d3        shifted four places?
  295.     bne.s    hshift        no, repeat
  296.     or.l    d1,d2        yes, add input character to variable
  297.     move.l    d2,4(a0,d0.w)    save current variable
  298.     bra.s    HEXip        get next character
  299.  
  300. Herror    lea    hInfo,a3    get start address of operator error info
  301.     bsr     nextlin        output message
  302.     ori    #1,ccr        set carry to indicate an error
  303.     rts    
  304.  
  305. ;******************************************************************
  306. ;*                                                                *
  307. ;*                  OCT Input handling Routine                    *
  308. ;*                                                                *
  309. ;******************************************************************
  310.  
  311. OCTip    bsr    getchar
  312.     bsr    oper        is the character an operator
  313.     bcc.s    Ono_op        if carry clear, character not an operator
  314.     andi    #0,ccr        clear carry before returning
  315.     rts
  316.  
  317. Ono_op    subi.b    #$30,d1        remove ascii offset
  318.     blt.s    Oerror        if input character is less than an ascii 0
  319.                 ;then in put is in error
  320.     cmpi.b    #7,d1        is in put character between ,including 0 - 7
  321.     bgt.s    Oerror        no, error
  322.  
  323. OCTnum    lea    VarPtr,a0
  324.     move.l    0(a0),d0    move VarPtr to d0
  325.     move.l    4(a0,d0.w),d2    get current variable
  326.     moveq    #0,d3        clear counter register
  327. Oshift    asl.l    #1,d2        shift left three bit places
  328.     bcs.s    Oerror        if carry set number intered was to large
  329.     addq    #1,d3        inc counter
  330.     cmpi    #3,d3        shifted 3?
  331.     bne.s    Oshift        no, do it again
  332.     or.l    d1,d2        add input to variable
  333.     move.l    d2,4(a0,d0.w)    save current variable
  334.     bra.s    OCTip        get next character
  335.  
  336. Oerror    lea    OInfo,a3    get start address of operator error info
  337.     bsr     nextlin        output message
  338.     ori    #1,ccr        set carry to indicate an error
  339.     rts
  340.  
  341. ;******************************************************************
  342. ;*                                                                *
  343. ;*                  BIN Input handling Routine                    *
  344. ;*                                                                *
  345. ;******************************************************************
  346.  
  347. BINip    bsr    getchar
  348.     bsr    oper        is the character an operator
  349.     bcc.s    Bno_op        carry clear, character not an operator
  350.     andi    #0,ccr        clear carry before returning
  351.     rts
  352.  
  353. Bno_op    subi.b    #$30,d1        remove ascii offset
  354.     blt.s    Berror        if input character is less than an ascii 0
  355.                 ;then in put is in error
  356.     cmpi.b    #1,d1        is in put character 0 or 1
  357.     bgt.s    Berror        no, error
  358.  
  359. BINnum    lea    VarPtr,a0
  360.     move.l    0(a0),d0    move VarPtr to d0
  361.     move.l    4(a0,d0.w),d2    get current variable
  362. Bshift    asl.l    #1,d2        shift left one bit place
  363.     bcs.s    Berror        if carry set number intered was to large
  364.     or.l    d1,d2        add input to variable
  365.     move.l    d2,4(a0,d0.w)    save current variable
  366.     bra.s    BINip        get next character
  367.  
  368. Berror    lea    BInfo,a3    get start address of operator error info
  369.     bsr     nextlin        output message
  370.     ori    #1,ccr        set carry to indicate an error
  371.     rts
  372.  
  373. ;******************************************************************
  374. ;*                                                                *
  375. ;*                  DEC Input handling Routine                    *
  376. ;*                                                                *
  377. ;******************************************************************
  378.  
  379. DECip    bsr    getchar
  380.     bsr    oper        is the character an operator
  381.     bcc.s    Dno_op        carry clear, character not an operator
  382.     tst.b    neg        test neg flag is set
  383.     beq.s    DECpos        if operator is "-" and neg flag clear,return
  384.     bsr.s    DECneg        if neg flaf set, make number negative
  385. DECpos    andi    #0,ccr        clear carry defore returning
  386.     rts
  387.  
  388. DECneg    lea    VarPtr,a0    if negative
  389.     move.l    0(a0),d0    move VarPtr to d0
  390.     move.l    4(a0,d0.w),d2    get current variable
  391.     neg.l    d2        make it negative
  392.     move.l    d2,4(a0,d0.w)    save current variable
  393.     clr.b    neg        clear negative flag
  394.     rts
  395.  
  396. Dno_op    subi.b    #$30,d1        remove ascii offset
  397.     blt.s    Derror        if input character is less than an ascii 0
  398.                 ;then in put is in error
  399.     cmpi.b    #9,d1        is in put character between, including 0 or 9
  400.     bgt.s    Derror        no, error
  401.  
  402. DECnum    lea    VarPtr,a0
  403.     move.l    0(a0),d0    move VarPtr to d0
  404.     move.l    4(a0,d0.w),d2    get current variable
  405.     move.l    d2,d3        mult by 10
  406.     asl.l    #1,d3        *2
  407.     bvs.s    Derror        if ovrflow input dec number is to large
  408.     move.l    d3,d4        save * 2 result
  409.     asl.l    #2,d3        *4, total of *8
  410.     bvs.s    Derror        if ovrflow input dec number is to large
  411.     add.l    d3,d4        add *2 result to *8 result
  412.     bmi.s    Derror        if becomes neg input dec number is to large
  413.     add.l    d1,d4        add input to value
  414.     move.l    d4,4(a0,d0.w)    save current variable
  415.     bra.s    DECip        get next character
  416.  
  417. Derror    lea    DInfo,a3    get start address of operator error info
  418.     bsr     nextlin        output message
  419.     ori    #1,ccr        clear carry before returning
  420.     rts
  421.  
  422. ;******************************************************************
  423. ;*                                                                *
  424. ;*                    Math Handling Routines                      *
  425. ;*                                                                *
  426. ;******************************************************************
  427.  
  428. ;******************************************************************
  429. ;*                                                                *
  430. ;*                         ADD Routine                            *
  431. ;*                                                                *
  432. ;******************************************************************
  433.  
  434. add    lea    VarPtr,a0
  435.     lea    Total,a1
  436.     moveq    #0,d1
  437.     move.l    0(a0),d0    move VarPtr to d0
  438.     move.l    4(a0),d2    move Var1 to d2
  439.     move.l    4(a0,d0.w),d3    move Var2 to d3
  440.     add.l    d3,d2        add variables
  441.     svs    err        if over flow, err = -1
  442.     bvc.s    addok        if add ok, save result and output 
  443.     lea    adderrI,a3    no, output error
  444.     bsr    nextlin
  445.     bra    addend
  446. addok    move.l    d1,(a1)        save result
  447.     move.l    d2,4(a1)
  448.     
  449. addend    rts
  450.  
  451. ;******************************************************************
  452. ;*                                                                *
  453. ;*                         SUB Routine                            *
  454. ;*                                                                *
  455. ;******************************************************************
  456.  
  457. sub    lea    VarPtr,a0
  458.     lea    Total,a1
  459.     moveq    #0,d1
  460.     move.l    0(a0),d0    move VarPtr to d0
  461.     move.l    4(a0),d2    move Var1 to d2
  462.     move.l    4(a0,d0.w),d3    move Var2 to d3
  463.     sub.l    d3,d2        var1 - var2
  464.     svs    err        if over flow, err = -1
  465.     bvc.s    subok        sub ok, save reult and output
  466.     lea    suberrI,a3    no, output error message
  467.     bsr    nextlin
  468.     bra    subend
  469. subok    move.l    d1,(a1)        save result
  470.     move.l    d2,4(a1)
  471.     
  472. subend    rts
  473.  
  474. ;******************************************************************
  475. ;*                                                                *
  476. ;*                         MULT Routine                           *
  477. ;*                         32 * 32 = 64                           *
  478. ;*                                                                *
  479. ;******************************************************************
  480.  
  481. mult    lea    VarPtr,a0
  482.     lea    Total,a1    a1 points to result storage area
  483.     move.l    0(a0),d0    move VarPtr to d0
  484.     move.l    4(a0),d1    move Var1 to d1
  485.     move.l    4(a0,d0.w),d2    move Var2 to d2
  486.     move.l    d1,d6        copy var1 to d6
  487.     move.l    d2,d7        copy var2 to d7
  488.  
  489. mul32    move.l    d1,d3        copy var1 to d3
  490.     move.l    d1,d4        and into d4
  491.     swap    d4        swaped form (upper 2 bytes swapped with lower)    
  492.     move.l    d2,d5        copy var2 to d5
  493.     swap    d5        in swapped form
  494.     mulu    d2,d1        partial product    #1
  495.     mulu    d4,d2                #2
  496.     mulu    d5,d3                #3
  497.     mulu    d5,d4                #4
  498.     swap    d1        sum1 = pp #2 low +
  499.     add    d2,d1        pp #1 high
  500.     clr.l    d5
  501.     addx.l    d5,d4        propagate carry into pp #4
  502.     add    d3,d1        sum2 = sum1 + pp #3 low
  503.     addx.l    d5,d4        propargate carry into pp #4
  504.     swap    d1        put low product in correct order
  505.     clr    d2        prepare for sum #3
  506.     swap    d2
  507.     clr    d3
  508.     swap    d3
  509.     add.l    d3,d2        sum3 = pp #2 low + pp #3 high
  510.     add.l    d4,d2        sum4 = sum3 + pp #4
  511.  
  512. ;
  513. ;    The following instructions modify the product if required
  514. ;
  515.  
  516.     tst.l    d7        val2 negative?
  517.     bpl.s    CHKd6        no, go check val1
  518.     sub.l    d6,d2        yes, sub val1 from product
  519.  
  520. CHKd6    tst.l    d6        val1 negative
  521.     bpl.s    mulend        no, finish
  522.     sub.l    d7,d2        yes, sub val2 from product
  523.  
  524. mulend    move.l    d2,(a1)        save result, high 32 bits
  525.     move.l    d1,4(a1)    low 32bits
  526.     
  527.     rts
  528.  
  529. ;******************************************************************
  530. ;*                                                                *
  531. ;*                         DIV Routines                           *
  532. ;*                                                                *
  533. ;******************************************************************
  534.  
  535. div    lea    VarPtr,a0
  536.     lea    Total,a1    a1 points to result storage error
  537.     move.l    0(a0),d0    move VarPtr to d0
  538.     move.l    4(a0),d2    move Var1 to d2
  539.     move.l    4(a0,d0.w),d1    move Var2 to d1
  540.  
  541. div0    moveq    #0,d6
  542.     moveq    #0,d7
  543.     tst.l    d1        is var2 negative or zero
  544.     seq    err        if zero, divid by zero
  545.     beq.s    dbyz        and output message
  546.     smi    d6        set d6 if var2 is negative
  547.     bpl.s    div1        positive, test next variable
  548.     neg.l    d1        make var2 positive
  549. div1    tst.l    d2        is var1 negative
  550.     smi    d7        set d7 if var1 is negative
  551.     bpl.s    div2        positive, divid var1 by var2
  552.     neg.l    d2        make var1 positive
  553. div2    eor    d6,d7        are signs different
  554.     sne.b    neg        if signs are different result must be neg
  555.  
  556.     cmpi.l    #$FFFF,d1    is var2 larger than 16 bits
  557.     sls    d6        if lower or same set d6 to -1
  558.     addi.b    #1,d6        calculate jump offset
  559.     lsl.l    #2,d6        *4 to get address
  560.     lea    divlen,a3    get address of jump table
  561.     move.l    0(a3,d6.w),a3    move address of divid routine to a3
  562.     jsr    (a3)
  563.  
  564. divend    move.l    d2,(a1)        quotient
  565.     move.l    d1,4(a1)    remainder
  566.     
  567.     rts
  568.  
  569. divlen    dc.l    d32.16,d32.32
  570.  
  571. dbyz    lea    dbyzI,a3    output divid by zero message
  572.     bsr    nextlin
  573.     rts
  574. ;
  575. ;    Use this routine if var2 is stored in 16 bits or less
  576. ;    Uses 68000 divid operand and accounts for over flow when the quotient
  577. ;    needs 32 bits instead of the standard 16
  578. ;
  579.  
  580. ;    d2 = dividend
  581. ;    d1 = divisor
  582.  
  583. d32.16    moveq    #0,d4
  584.     divu    d1,d2        Has overflow occurred?
  585.     bvc.s    dformat        No, go format result
  586.     move.l    d2,d3        Yes, copy yo into d3
  587.     clr.w    d2        clr low word of d2, y1-y0 to y1-0
  588.     swap    d2        y1-0 to 0-y1
  589.     divu    d1,d2        div puts r1-q1 into d2
  590.     move    d2,d4        d3 contains q1
  591.     move    d3,d2        d1 changes from r1-q1 to r1-y0
  592.     divu    d1,d2        div puts r0-q0 into d1
  593.  
  594. ;
  595. ;    Form quotient (D2) and remainder (D1)
  596. ;
  597.  
  598. dformat    move.l    d2,d1        d1 contains r-q or r0-q0
  599.     swap    d2        d2 contains q-r or q0-r0
  600.     move    d4,d2        d2 contains q-0 or q0-q1
  601.     swap    d2        d2 contains 0-q or q1-q0
  602.     clr    d1        d1 contains r-0 or r0-0
  603.     swap    d1        d1 contains 0-r or 0-r0
  604.  
  605.     tst.b    neg        is result to be negative
  606.     beq.s    d32.16e        no, return
  607.     neg.l    d2        yes, make neqative
  608.     neg.l    d1
  609.     clr.b    neg
  610.  
  611. d32.16e    rts
  612.  
  613. ;
  614. ;    Use this routine if var2 is stored in 16 bits or less
  615. ;    Uses a divid algorithm
  616.  
  617. ;
  618. ;    d2 = dividend
  619. ;    d1 = divisor
  620. ;
  621.  
  622. d32.32    cmp.l    d2,d1        divisor = dividend
  623.     bne.s    divi1        no, divid out
  624.     moveq    #1,d3        yes, result = 1
  625.     moveq    #0,d2        zero remainder
  626.     bra.s    divout        return
  627.  
  628. divi1    cmp.l    d2,d1        dividend > divisor?
  629.     bcs.s    divi2        yes, result is > 0
  630.     moveq    #0,d3        else result = 0 + r        
  631.     bra.s    divout        return
  632.  
  633. divi2    moveq    #0,d4        initialise iteration count
  634.  
  635. divi3    addq    #1,d4        inc count
  636.     asl.l    #1,d1        see if d1 goes > 0
  637.     bmi.s    divi4        it did if now neg
  638.     cmp.l    d1,d2        d1 > 0
  639.     bcc.s    divi3        no, try again
  640.  
  641. divi4    lsr.l    #1,d1        readjust divisor
  642.     moveq    #0,d3        initialise quotient
  643.  
  644. divi5    sub.l    d1,d2        divisor goes in
  645.     bmi.s    divi6        no
  646.     addq    #1,d3        else record it
  647.     bra.s    divi7        
  648.  
  649. divi6    add.l    d1,d2        restore dividend
  650.  
  651. divi7    subq    #1,d4        done all bits?
  652.     beq.s    divout        yes
  653.     asl.l    #1,d3        quotient * 2
  654.     asr.l    #1,d1        divisor / 2
  655.     bra.s    divi5        next round
  656.  
  657. divout    move.l    d2,d1        move remainder to d1
  658.     move.l    d3,d2        move quotient to result
  659.     tst.b    neg        should result be neg
  660.     beq.s    d32.32e        no exit        
  661.     neg.l    d2        change sign of result
  662.     neg.l    d1
  663.     clr.b    neg
  664.  
  665. d32.32e    rts
  666.  
  667.  
  668. ;******************************************************************
  669. ;*                                                                *
  670. ;*                   Output Handling Routines                     *
  671. ;*                                                                *
  672. ;******************************************************************
  673.  
  674. ;******************************************************************
  675. ;*                             HtoA                               *
  676. ;*           Converts variable pointed to by VarPtr to            *
  677. ;*               a HEX ascii string for displaying.               *
  678. ;******************************************************************
  679.  
  680. HtoA    lea    VarPtr,a0
  681.     move.l    #12,d4        point to result
  682.     lea    BuffT,a1    get address of tempory buffer
  683.     move.l    #147,d3        point to end of buffer
  684.  
  685. GetH    move.l    4(a0,d4),d0    get a varible
  686.  
  687.     cmpi.b    #12,d4        pointing to result
  688.     blt.s    GetH0        no, no special trement
  689.     cmpi.b    #4,func        is operation div
  690.     beq.s    Hdiv        yes, output in divid format
  691.  
  692. GetH0    cmpi    #8,d4        remove if leading zeros are to be removed
  693.     bne.s    GetH1                "
  694.     tst.l    d0                "
  695.     bne.s    GetH1                "
  696.     subq    #4,d4                "
  697.     bsr    Iequal                "
  698.     bra.s    GetH                "
  699.     
  700. GetH1    bsr    HtoAt        change variable  to ascii in HEX base
  701.     tst.b    err        error in converstion
  702.     bne.s    HtoAerr        output error message
  703.  
  704. nextH    subq    #4,d4        point to next variable
  705.     bmi.s    BTtoBH        if negative all variables actioned
  706.     beq.s    Hoper        d4 = 0, then output relavent operator
  707.  
  708. Hequal    cmpi    #4,d4        has total been actioned
  709.     bhi.s    GetH        higher, get high 32 bits of result
  710.     bsr    Iequal        d4 = 4, insert "=" sign
  711.     bra.s    GetH        get next variable
  712.  
  713. Hoper    bsr    Ifunc        branch to insert operator routine 
  714.     bra    GetH        get next variable
  715.  
  716. BTtoBH    lea    BuffH,a0    a0 points to HEX output buffer
  717.     ;jsr    Rled0        remove leading zeros
  718.     jsr    BTcopy        do not remove leading zeros
  719.     rts
  720.  
  721. Hdiv    move.l    #9,d5        insert "remainder" into tempory buffer
  722.     lea    rem,a2        a2 points to remainder
  723. Hdiv1    move.b    0(a2,d5.w),d6    get a letter
  724.     move.b    d6,0(a1,d3.w)    put it into tempory buffer
  725.     subq    #1,d3        point to next letter
  726.     dbf    d5,Hdiv1    d5 = 0, then finished
  727.  
  728. Hdiv2    bsr    HtoAt        convet to ascii, HEX base
  729.     move.b    #' ',0(a1,d3.w)    add "+" to buffer
  730.     subq    #1,d3
  731.     move.b    #'+',0(a1,d3.w)
  732.     subq    #1,d3
  733.     move.b    #' ',0(a1,d3.w)
  734.     subq    #1,d3
  735.     subq    #4,d4        point to quotient
  736.     move.l    4(a0,d4.w),d0    get quotient
  737.  
  738.     bsr    HtoAt        convert to ascii, HEX base
  739.     bra    nextH        get var2
  740.  
  741.  
  742. HtoAerr    lea    HtoAI,a3    output error message
  743.     bsr    nextlin
  744.     rts
  745.  
  746.  
  747. HtoAt    moveq    #8,d1        do not remove leading zeros
  748.                 ;move to remove leading zeros
  749.  
  750. HtoAtp    move.l    d0,d2
  751.     andi.l    #$0000000F,d2    get lsnibble
  752.     addi.l    #$30,d2        ascii offset for num
  753.     cmpi.l    #$39,d2        larger than $39
  754.     ble.s    HtoAct        no do not add $7, yes, add $7
  755.     addq.l    #$7,d2        ascii offset for alpha
  756. HtoAct    move.b    d2,0(a1,d3.w)    move to tempory buffer
  757.     subq    #1,d3        point to next buffer place
  758.     lsr.l    #4,d0        move next byte into LSnibble
  759.     
  760.     subq    #1,d1        decrememt counter, remove to delete leading
  761.                 ;zero
  762.     smi.b    err        if negative, an error has occurred
  763.     bgt.s    HtoAtp        if greater convert next byte
  764.     
  765.     rts
  766.     
  767. ;******************************************************************
  768. ;*                             OtoA                               *
  769. ;*           Converts variable pointed to by VarPtr to            *
  770. ;*               a OCT ascii string for displaying.               *
  771. ;******************************************************************
  772.  
  773. OtoA    lea    VarPtr,a0
  774.     move.l    #12,d4        point to result
  775.     lea    BuffT,a1    get address of tempory buffer
  776.     move.l    #147,d3        point to end of buffer
  777.  
  778. GetO    move.l    4(a0,d4),d0    get a varible
  779.  
  780.     cmpi.b    #12,d4        pointing to result
  781.     blt.s    GetO0        no, no special treatment
  782.     cmpi.b    #4,func        is operation div
  783.     beq.s    Odiv        yes, output in divid format
  784.     
  785. GetO0    cmpi    #8,d4        remove if leading zeros are to be removed
  786.     bne.s    GetO1                "
  787.     tst.l    d0                "    
  788.     bne.s    GetO1                "
  789.     subq    #4,d4                "
  790.     bsr    Iequal                "    
  791.     bra.s    GetO                "                "
  792.     
  793. GetO1    bsr    OtoAt        change variable  to ascii in OCT base
  794.     tst.b    err        error in converstion
  795.     bne.s    OtoAerr        output error message
  796.  
  797. nextO    subq    #4,d4        point to next variable
  798.     bmi.s    BTtoBO        if negative all variables actioned
  799.     beq.s    Ooper        d4 = 0, then output relavent operator
  800.  
  801. Oequal    cmpi    #4,d4        has total been actioned
  802.     bhi.s    GetO        higher, get high 32 bits of result
  803.     bsr    Iequal        d4 = 4, insert "=" sign
  804.     bra.s    GetO        get next variable
  805.  
  806. Ooper    bsr    Ifunc        branch to insert operator routine
  807.     bra    GetO        get next variable
  808.  
  809. BTtoBO    lea    BuffO,a0    a0 points to OCT output buffer
  810.     ;jsr    Rled0        remove leading zeros
  811.     jsr    BTcopy        do not remove leading zeros
  812.     rts
  813.  
  814. Odiv    move.l    #9,d5        insert "remainder" into tempory buffer
  815.     lea    rem,a2        a2 points to remainder
  816. Odiv1    move.b    0(a2,d5.w),d6    get a letter
  817.     move.b    d6,0(a1,d3.w)    put it into tempory buffer
  818.     subq    #1,d3        point to next letter
  819.     dbf    d5,Odiv1    d5 = 0, then finished
  820.  
  821. Odiv2    bsr    OtoAt        convet to ascii, BIN base
  822.     move.b    #' ',0(a1,d3.w)    if so add + to buffer
  823.     subq    #1,d3
  824.     move.b    #'+',0(a1,d3.w)
  825.     subq    #1,d3
  826.     move.b    #' ',0(a1,d3.w)
  827.     subq    #1,d3
  828.     subq    #4,d4        point to quotient
  829.     move.l    4(a0,d4.w),d0    get quotient
  830.  
  831.     bsr    OtoAt        convert to ascii, OCT base
  832.     bra    nextO        get var2
  833.  
  834. OtoAerr    lea    HtoAI,a3    output error message
  835.     bsr    nextlin
  836.     rts
  837.  
  838. OtoAt    moveq    #11,d1        do not remove leading zeros
  839.                 ;move to remove leading zeros
  840.  
  841. OtoAtp    move.l    d0,d2
  842.     andi.l    #$00000007,d2    get lsf
  843.     addi.l    #$30,d2        ascii offset for num
  844.  
  845. OtoAct    move.b    d2,0(a1,d3.w)    move to tempory buffer
  846.     subq    #1,d3        point to next buffer place
  847.     lsr.l    #3,d0        move next byte into LSBits (3)
  848.  
  849.     subq    #1,d1        decrememt counter, remove to delete leading
  850.                 ;zeros
  851.     smi    err        if negative, an error has occurred
  852.     bgt.s    OtoAtp        if greater convert next 3 bits
  853.     
  854.     rts
  855.  
  856. ;******************************************************************
  857. ;*                             BtoA                               *
  858. ;*           Converts variable pointed to by VarPtr to            *
  859. ;*               a BIN ascii string for displaying.               *
  860. ;******************************************************************
  861.  
  862. BtoA    lea    VarPtr,a0
  863.     move.l    #12,d4        point to result
  864.     lea    BuffT,a1    get address of tempory buffer
  865.     move.l    #147,d3        point to end of buffer
  866.  
  867. GetB    move.l    4(a0,d4),d0    get a varible
  868.  
  869.     cmpi.b    #12,d4        pointing to result
  870.     blt.s    GetB0        no, no special treatment
  871.     cmpi.b    #4,func        is operation div
  872.     beq.s    Bdiv        yes, output in divid format
  873.  
  874. GetB0    cmpi    #8,d4        remove if leading zeros are to be removed
  875.     bne.s    GetB1                "
  876.     tst.l    d0                "
  877.     bne.s    GetB1                "
  878.     subq    #4,d4                "
  879.     bsr    Iequal                "
  880.     bra.s    GetB                "                "
  881.     
  882. GetB1    bsr    BtoAt        change variable  to ascii in BIN base
  883.     tst.b    err        error in converstion
  884.     bne.s    BtoAerr        output error message    
  885.  
  886. nextB    subq    #4,d4        point to next variable
  887.     bmi.s    BTtoBB        if negative all variables actioned
  888.     beq.s    Boper        d4 = 0, then output relavent operator
  889.  
  890. Bequal    cmpi    #4,d4        has total been actioned
  891.     bhi.s    GetB        higher, get high 32 bits of result
  892.     bsr    Iequal        d4 = 4, insert "=" sign
  893.     bra.s    GetB        get next variable
  894.  
  895. Boper    bsr    Ifunc        branch to insert operator routine
  896.     bra    GetB        get next variable
  897.  
  898. BTtoBB    lea    BuffB,a0    a0 points to BIN output buffer
  899.     ;jsr    Rled0        remove leding zeros
  900.     jsr    BTcopy        do not remove leading zeros
  901.     rts
  902.  
  903. Bdiv    move.l    #9,d5        insert "remainder" into tempory buffer
  904.     lea    rem,a2        a2 points to remainder
  905. Bdiv1    move.b    0(a2,d5.w),d6    get a letter
  906.     move.b    d6,0(a1,d3.w)    put it into tempory buffer
  907.     subq    #1,d3        point to next letter
  908.     dbf    d5,Bdiv1    d5 = 0, then finished
  909.  
  910. Bdiv2    bsr    BtoAt        convet to ascii, BIN base
  911.     move.b    #' ',0(a1,d3.w)    if so add + to buffer
  912.     subq    #1,d3
  913.     move.b    #'+',0(a1,d3.w)
  914.     subq    #1,d3
  915.     move.b    #' ',0(a1,d3.w)
  916.     subq    #1,d3
  917.     subq    #4,d4        point to quotient
  918.     move.l    4(a0,d4.w),d0    get quotient
  919.  
  920.     bsr    BtoAt        convert to ascii, BIN base
  921.     bra    nextB        get var2
  922.  
  923. BtoAerr    lea    HtoAI,a3    output error message
  924.     bsr    nextlin
  925.     bra    quit
  926.  
  927. BtoAt    move.l    #32,d1        do not remove leading zeros
  928.                 ;move to remove leading zeros
  929.  
  930.  
  931. BtoAtp    move.l    d0,d2
  932.     andi.l    #$00000001,d2    get lsbit
  933.     addi.l    #$30,d2        ascii offset for num
  934.  
  935. BtoAct    move.b    d2,0(a1,d3.w)    move to tempory buffer
  936.     subq    #1,d3        point to next buffer place
  937.     lsr.l    #1,d0        move next byte into LSBit
  938.  
  939.     subq    #1,d1        decrememt counter, remove to delete leading
  940.                 ;zeros
  941.     smi    err        if negative, an error has occurred
  942.     bgt.s    BtoAtp        if greater convert next bit
  943.     
  944.     rts
  945.  
  946. ;******************************************************************
  947. ;*                              DtoA                              *
  948. ;*           Converts variable pointed to by VarPtr to            *
  949. ;*               a DEC ascii string for displaying.               *
  950. ;******************************************************************
  951.  
  952. DtoA    lea    VarPtr,a0
  953.     move.l    #12,d4        point to result
  954.     lea    BuffT,a1    get address of tempory buffer
  955.     move.l    #147,d3        point to end of buffer
  956.     
  957.  
  958. GetD    move.l    4(a0,d4.w),d0    get a variable
  959.     cmpi.b    #12,d4        pointing to result
  960.     blt.s    GetD0        no, no special treatment
  961.     cmpi.b    #3,func        is operation mult or div
  962.     beq    Dtmul        if equal, output in mult format
  963.     bgt    Dtdiv        if greater, output in div format
  964. GetD0    tst.l    d0        find sign of variable
  965.     bge.s    GetD1
  966.     smi    neg        neg, set neg flag 
  967.     neg.l    d0        make number possible
  968. GetD1    bsr    HtoBCD        change variable  to ascii in DEC base
  969.     
  970.  
  971. nextD    subq    #4,d4        point to next variable
  972.     bmi    BTtoBD        if negative all variables actioned
  973.     beq.s    Doper        d4 = 4, then insert operator
  974.  
  975. Dequal    cmpi    #4,d4        has total been actioned
  976.     bhi.s    Getr        no, go to save to buffer routine
  977.     bsr    DequalI        yes, insert "=" in tempory buffer
  978.     bra.s    GetD        get next variable
  979.  
  980. Getr    bsr    DtoAct        move result from DecTemp to Tempory Buffer
  981.     subq    #4,d4        point to next variable
  982.     bsr    Iequal        insert "=" into tempory buffer
  983.     bra    GetD        get next variable
  984.  
  985. Doper    bsr    DtoAct        move var2 from DecTemp to Tempory Buffer
  986.     bsr    Ifunc        then insert operator
  987.     bra    GetD        get var1
  988.  
  989. DequalI    bsr    DtoAct        move result from DecTemp to Tempory Buffer
  990.     bsr    Iequal        then insert equal sign
  991.     rts
  992.  
  993. BTtoBD    bsr    DtoAct        move DecTemp to Buffer
  994.     lea    BuffD,a0    point to DEC output buffer
  995.     jsr    Rled0        remove leading zero's and move to output buffer
  996.     rts
  997.  
  998. ;    Dtmul uses two longwords to calculate decimal equivalent
  999.  
  1000. Dtmul    tst.l    0(a0,d4.w)    is variable negative
  1001.     bge.s    Dtmul1        no, convert
  1002.     smi    neg        yes, set neg flag
  1003.     neg.l    d0        neg low word
  1004.     negx.l    0(a0,d4.w)    neg (account for borrow if used for low word)
  1005. Dtmul1    bsr    HtoBCD        change variable  to ascii in DEC base
  1006.     subq    #4,d4        point to next variable
  1007.     move.l    4(a0,d4.w),d0    get high 32 bits
  1008.     bsr    BCDT        miss out set up routine in HtoBCD
  1009.     bra    nextD        move to tempory buffer and get next var2
  1010.  
  1011. ;    Dtdiv uses the lowword for remainder, high word for quotient
  1012.  
  1013. Dtdiv    move.l    #9,d5        insert "remainder" into tempory buffer
  1014.     lea    rem,a2        a2 points to remainder
  1015. Dtdiv1    move.b    0(a2,d5.w),d6    get a letter
  1016.     move.b    d6,0(a1,d3.w)    put it into tempory buffer
  1017.     subq    #1,d3        point to next letter
  1018.     dbf    d5,Dtdiv1    d5 = 0, then finished
  1019.     tst.l    d0        is remainder negative
  1020.     bpl.s    Dtdiv2        no, convert
  1021.     smi    neg        yes, set neg flag
  1022.     neg.l    d0        and make poitive
  1023. Dtdiv2    bsr    HtoBCD        change variable  to ascii in DEC base
  1024.     bsr    DtoAct        move to tempory buffer
  1025.     tst.b    neg        was number negative
  1026.     bpl.s    Dtdiv3        no, add "+" to buffer
  1027.     move.b    #' ',0(a1,d3.w)    yes, so add - to buffer
  1028.     subq    #1,d3
  1029.     move.b    #'-',0(a1,d3.w)
  1030.     subq    #1,d3
  1031.     move.b    #' ',0(a1,d3.w)
  1032.     subq    #1,d3
  1033.     clr.b    neg        clear neg flag
  1034.     bra.s    Dtdiv4        convert quotient
  1035. Dtdiv3    move.b    #' ',0(a1,d3.w)    add + to buffer
  1036.     subq    #1,d3
  1037.     move.b    #'+',0(a1,d3.w)
  1038.     subq    #1,d3
  1039.     move.b    #' ',0(a1,d3.w)
  1040.     subq    #1,d3
  1041. Dtdiv4    subq    #4,d4        point to next variable
  1042.     move.l    4(a0,d4.w),d0    get quotient
  1043.     tst.l    d0        is it negative
  1044.     smi.b    neg        set neg flag if negative
  1045.     bpl.s    Dtdiv5        no, convert
  1046.     neg.l    d0        yes, make it positive
  1047. Dtdiv5    bsr    HtoBCD        change variable  to ascii in BIN base
  1048.     bra    nextD        move to tempory buffer and get var2
  1049.  
  1050. ;    HtoBCD converts a HEX number to BCD
  1051.  
  1052. HtoBCD    moveq    #0,d5        clear d5
  1053.     move.l    #DecSize,d2    get size of DecTemp    
  1054.     lea    DecTemp,a2    get address of DecTemp
  1055. HtoBCD2    move.b    d5,0(a2,d2.w)    clear a2 + d2
  1056.     dbmi.w    d2,HtoBCD2    all done, no do it again
  1057.     lea    DecCon1,a2    get address of DecCon1
  1058.  
  1059. BCDT    moveq    #8,d1        d1 holds the number of nibbles to do
  1060.  
  1061. BCDT0    move.l    d0,d2        move variable to d2
  1062.     andi.l    #$0000000F,d2    get lsnibble
  1063.  
  1064. BCDT1    beq.s    BCDT3        if zero get next significant nibble
  1065.     lea    DecCon0,a4    get address of DecCon0
  1066.     andi    #$EF,ccr    clear extended flag in ccr
  1067.     move.l    a2,a3
  1068.     adda.l    d5,a3        calculate 16^x pointer
  1069.  
  1070. BCDT2    abcd    -(a3),-(a4)    add BCD from number pointed to by a3 to DecTemp
  1071.     cmpa.l    #DecTemp,a4    all bytes added
  1072.     bne.s    BCDT2        no, do next byte, elseget next significant nib
  1073.     subq    #1,d2        sub 1 from hex number
  1074.     bra    BCDT1        do again
  1075.  
  1076. BCDT3    lsr.l    #4,d0        move next significant nibble into lsnibble
  1077.     addi.l    #12,d5        point to next 16^x (x = D5)
  1078.     subq    #1,d1        dec nibble count
  1079.     bne.s    BCDT0        if not zero do it again
  1080.  
  1081. BCDend    rts    
  1082.     
  1083. ;    DtoAct converts a BCD number to ASCII and moves it to a tempory buffer
  1084.  
  1085. DtoAct    lea    DecCon0,a4    point to end of DecTemp
  1086. DtoAct1    moveq    #2,d5        d5 = nibble count
  1087.     move.b    -(a4),d0    move byte from DecTemp into d0
  1088. DtoAct2    move.b    d0,d2        
  1089.     andi    #$F,d2        get lsnibble
  1090.     add.b    #$30,d2        convert it to an ascii number
  1091.     move.b    d2,0(a1,d3.w)    move to tempory buffer
  1092.     subq    #1,d3        point to next buffer position
  1093.     lsr    #4,d0        move nibble into lsnibble position
  1094.     subq    #1,d5        dec nibble count
  1095.     bne.s    DtoAct2        all nibbles done, no do next nibble
  1096.  
  1097. DtoAct3    cmpa.l    #DecTemp-1,a4    else, all of DecTemp done?
  1098.     bne.s    DtoAct1        no, done next byte
  1099.     tst.b    neg        was number negative
  1100.     beq.s    DtoActe        no return
  1101.     move.b    #'-',0(a1,d3.w)    else put negative in front of number
  1102.     subq    #1,d3        point to next buffer position
  1103.     clr.b    neg        clear neg flag
  1104. DtoActe    rts
  1105.  
  1106. DtoAerr    lea    HtoAI,a3    print error message
  1107.     bsr    nextlin
  1108.     rts
  1109.  
  1110. ***********************************************************
  1111.  
  1112. Iequal    move.b    #' ',0(a1,d3.w)    add " = " to buffer
  1113.     subq    #1,d3
  1114.     move.b    #'=',0(a1,d3.w)
  1115.     subq    #1,d3
  1116.     move.b    #' ',0(a1,d3.w)
  1117.     subq    #1,d3
  1118.     rts
  1119.  
  1120. Ifunc    move.b    #' ',0(a1,d3.w)    add function to buffer
  1121.     subq    #1,d3
  1122.     moveq    #0,d5
  1123.     move.b    func,d5
  1124.     subq    #1,d5
  1125.     lsl    #2,d5        cal index for jump table
  1126.     lea    funcH,a3    get address of jump table
  1127.     move.l    0(a3,d5.w),a3    get address of func routine
  1128.     jsr    (a3)        insert correct function
  1129.     move.b    #' ',0(a1,d3.w)
  1130.     subq    #1,d3
  1131.     rts
  1132.  
  1133. funcH    dc.l    Iadd,Isub,Imult,Idiv
  1134.  
  1135. Iadd    move.b    #'+',0(a1,d3.w)    add + to buffer
  1136.     subq    #1,d3
  1137.     rts
  1138.  
  1139. Isub    move.b    #'-',0(a1,d3.w)    add - to buffer
  1140.     subq    #1,d3
  1141.     rts
  1142.  
  1143. Imult    move.b    #'*',0(a1,d3.w)    add * to buffer
  1144.     subq    #1,d3
  1145.     rts
  1146.  
  1147. Idiv    move.b    #'/',0(a1,d3.w)    add / to buffer
  1148.     subq    #1,d3
  1149.     rts
  1150.  
  1151. ;******************************************************************
  1152. ;*                   Rmzero  Kill leading zeros                   *
  1153. ;*           Inputs: a0 pointer to destination buffer             *
  1154. ;*                   a1 pointer to source                         *
  1155. ;******************************************************************
  1156.  
  1157. Rled0    moveq    #0,d0
  1158.     moveq    #0,d2
  1159.     moveq    #0,d1
  1160.     addq    #1,d3        compensate for last subq of d3
  1161. Rled01    move.b    0(a1,d3.w),d0    get character from buffer
  1162.     addq    #1,d3
  1163.     cmpi.b    #$30,d0        is it a zero
  1164.     bne.s    Rled02        check for other characters of interest
  1165.     tst    d1        has a character been output
  1166.     beq.s    Rled01        no, geet next character
  1167.     bne.s    BtoB2        yes, output "0"
  1168.         
  1169. Rled02    cmpi.b    #$20,d0        is the character a space
  1170.     beq.s    BtoB        yes, check if input betwwen spaces
  1171.     cmpi    #'-',d0        is it "-"?
  1172.     beq.s    BtoB3        move it to out put buffer
  1173.     cmpi.b    #LF,d0        end of tempory buffer
  1174.     bne.s    BtoB2        no, put character into buffer
  1175.     tst    d1        character between last space and Line Feed
  1176.     bne    Tnzero        yes, put into buffer
  1177.     move.b    #'0',0(a0,d2.w)    no, insert a "0" before Line Feed
  1178.     addq    #1,d2
  1179.     moveq    #LF,d0
  1180. Tnzero    move.b    d0,0(a0,d2.w)    move to output buffer
  1181.     addq    #1,d2        inc output buffer pointer
  1182.     move.b    #0,0(a0,d2.w)    put a NULL at end of output string
  1183.     rts
  1184.  
  1185.     
  1186. BtoB    tst    d1        has a character been output
  1187.     beq.s    Val0        no, insert a "0"
  1188.     moveq    #3,d1        yes, d1 is used to count three characters
  1189.                 ;move " ? " to output buffer. (? = +,-,*,/,=)
  1190. BtoB1    move.b    d0,0(a0,d2.w)    move character to output buffer
  1191.     addq    #1,d2        inc buffer pointer
  1192.     subq    #1,d1        dec character counter
  1193.     beq.s    BtoB1e        all done, reset character output flag
  1194.     move.b    0(a1,d3.w),d0    get character from temp buffer
  1195.     addq    #1,d3        inc buffer pointer
  1196.     bra    BtoB1        do again
  1197.  
  1198. BtoB1e    moveq    #0,d1        clear output flag
  1199.     bra.s    Rled01        get next character
  1200.  
  1201. BtoB2    move.b    d0,0(a0,d2.w)    move character to output buffer
  1202.     addq    #1,d2        inc buffer pointer
  1203.     addq    #1,d1        inc buffer pointer
  1204.     bra    Rled01        get next character
  1205.     
  1206. BtoB3    move.b    d0,0(a0,d2.w)    move character to output buffer
  1207.     addq    #1,d2        inc buffer pointer
  1208.     bra    Rled01        get next character
  1209.  
  1210. Val0    move.b    #'0',0(a0,d2.w)    move "0" to output buffer
  1211.     addq    #1,d2        inc buffer pointer
  1212.     moveq    #3,d1        move " ? " to output buffer. (? = +,-,*,/,=)
  1213.     bra.s    BtoB1
  1214.  
  1215. ;******************************************************************
  1216. ;*           Copy from tempory buffer to output buffer            *
  1217. ;*           Inputs: a0 pointer to destination buffer             *
  1218. ;*                   a1 pointer to source                         *
  1219. ;******************************************************************
  1220.  
  1221. BTcopy    moveq    #0,d0
  1222.     moveq    #0,d2
  1223.     moveq    #0,d1
  1224.     addq    #1,d3        compensate for last subq of d3
  1225. BTcopy1    move.b    0(a1,d3.w),d0    get character from buffer
  1226.     addq    #1,d3        inc buffer pointer
  1227.     cmpi.b    #LF,d0        end of tempory buffer
  1228.     beq.s    BTcopy2        yes, end routine
  1229.     move.b    d0,0(a0,d2.w)    move character to output buffer
  1230.     addq    #1,d2        inc buffer pointer
  1231.     bra    BTcopy1        get next character
  1232.  
  1233. BTcopy2    move.b    d0,0(a0,d2.w)    move character to output buffer
  1234.     addq    #1,d2        inc buffer pointer
  1235.     move.b    #0,0(a0,d2.w)    put a NULL at end of output string
  1236.     rts
  1237.  
  1238.  
  1239. ;******************************************************************
  1240. ;*                                                                *
  1241. ;*                    Variables and Constants                     *
  1242. ;*                                                                *
  1243. ;******************************************************************
  1244.  
  1245. VarPtr    ds.l    1
  1246. Var1    ds.l    1
  1247. Var2    ds.l    1
  1248. Total    ds.l    2
  1249.  
  1250. func    dc.b    0    ; 0,1,2,3,4 none,add,sub,Mult,Div
  1251.  
  1252. neg    dc.b    0
  1253.  
  1254. err    dc.b    0
  1255.     
  1256. BuffT    ds.b    148
  1257. BuffTE    dc.b    $0a
  1258.  
  1259. BuffHS    dc.b    "HEX   "
  1260. BuffH    ds.b    52
  1261. BuffHe    dc.b    0
  1262. BuffOS    dc.b    "OCT   "
  1263. BuffO    ds.b    64
  1264. BuffOE    dc.b    0
  1265. BuffBS    dc.b    "BIN   "
  1266. BuffB    ds.b    148
  1267. BuffBE    dc.b    0
  1268. BuffDS    dc.b    "DEC   "
  1269. BuffD    ds.b    55
  1270. BuffDE    dc.b    0
  1271. rem    dc.b    " remainder"
  1272.  
  1273.  
  1274.     even
  1275.     
  1276. DecTemp    ds.w    6
  1277. DecCon0    dc.w    $0000,$0000,$0000,$0000,$0000,$0001
  1278. DecCon1    dc.w    $0000,$0000,$0000,$0000,$0000,$0016
  1279. DecCon2    dc.w    $0000,$0000,$0000,$0000,$0000,$0256
  1280. DecCon3    dc.w    $0000,$0000,$0000,$0000,$0000,$4096
  1281. DecCon4    dc.w    $0000,$0000,$0000,$0000,$0006,$5536
  1282. DecCon5    dc.w    $0000,$0000,$0000,$0000,$0104,$8576
  1283. DecCon6    dc.w    $0000,$0000,$0000,$0000,$1677,$7216
  1284. DecCon7    dc.w    $0000,$0000,$0000,$0002,$6843,$5456
  1285. DecCon8    dc.w    $0000,$0000,$0000,$0042,$9496,$7296
  1286. DecCon9    dc.w    $0000,$0000,$0000,$0687,$1947,$6736
  1287. DecConA    dc.w    $0000,$0000,$0001,$0995,$1162,$7776
  1288. DecConB    dc.w    $0000,$0000,$0017,$5921,$8604,$4416
  1289. DecConC    dc.w    $0000,$0000,$0281,$4749,$7671,$0656
  1290. DecConD    dc.w    $0000,$0000,$4503,$5996,$2737,$0496
  1291. DecConE    dc.w    $0000,$0007,$2057,$5940,$3792,$7936
  1292. DecConF    dc.w    $0000,$0115,$2921,$5046,$0694,$6976
  1293. DecEND    dc.w    $0000,$0000,$0000,$0000,$0000,$0000
  1294.  
  1295. DecSize    equ    (DecCon0-DecTemp)-1
  1296.  
  1297.     even
  1298. ipadd    dc.l    0
  1299. iplen    dc.w    0
  1300. stdout    dc.l    0
  1301. stdin    dc.l    0
  1302. DosBase    dc.l    0
  1303. DosName    dc.b    "dos.library",0
  1304.  
  1305. LF    equ    $0a
  1306.  
  1307. blank    dc.b    LF,0
  1308.  
  1309. HtoAI    dc.b    "You stuffed it up again",LF,0
  1310.  
  1311. oInfo    dc.b    "Error in operator",LF,0
  1312.  
  1313. hInfo    dc.b    "Error in hexadecimal number",LF,0
  1314.  
  1315. OInfo    dc.b    "Error in octal number",LF,0
  1316.  
  1317. BInfo    dc.b    "Error in binary number",LF,0
  1318.  
  1319. DInfo    dc.b    "Error in Decimal number",LF,0
  1320.  
  1321. adderrI    dc.b    "Overflow occured in addition, numbers are to large.",LF,0
  1322.  
  1323. suberrI    dc.b    "Overflow occured in subtraction, numbers are to large.",LF,0
  1324.  
  1325. dbyzI    dc.b    "Divid by zero",LF,0
  1326.  
  1327. Info    dc.b    "CAL <base> number operator <base> number <=> [return]",LF
  1328.     dc.b    " base: $ = HEX, @ = Octal, % = binary, none = decimal",LF
  1329.     dc.b    " number: HEX max 7FFFFFFF t0 80000000,",LF
  1330.     dc.b    "         Decimal max +/-2147483647",LF 
  1331.     dc.b    " operator: +,-,*,/",LF,LF,0
  1332.  
  1333.     end
  1334.  
  1335.